#include "FileHandler.h"

FileHandler::FileHandler()
{
    this->inicializador();
}

FileHandler::FileHandler(const FileHandler& fh)
{
    this->tamanho = fh.tamanho;
    if(this->get_tamanho())
    {
        this->texto = new (nothrow) string[this->get_tamanho()];
        if(this->get_texto())
        {
            copy(fh.texto,fh.texto+fh.tamanho,this->texto);
            return;
        }
    }
    this->inicializador();
}

FileHandler::~FileHandler()
{
    delete[] texto;
}

void FileHandler::inicializador()
{
    texto = NULL;
    tamanho = 0;
}

void trocar_atributos(FileHandler& pri, FileHandler& seg)
{
    swap(pri.tamanho,seg.tamanho);
    swap(pri.texto  ,seg.texto);
}

FileHandler& FileHandler::operator=(FileHandler fh)
{
    trocar_atributos(*this,fh);
    return(*this);
}

string* FileHandler::get_texto()
{
    return(texto);
}

size_t FileHandler::get_tamanho()
{
    return(tamanho);
}

bool FileHandler::ler(const char *arquivo_nome)
{
    list<string> linhas_lidas;
    // Abrir o arquivo para leitura:
    ifstream arquivo(arquivo_nome);
    // Se for possível abrir o arquivo:
    if(arquivo.is_open())
    {
        string linha;
        while(arquivo.good())
        {
            getline(arquivo,linha);
            // Ignorar linhas vazias:
            if(!linha.empty()) linhas_lidas.push_back(linha);
        }
        linha.clear();
        arquivo.close();
        // Checar algum texto foi lido do arquivo e posto na lista temporária:
        if(linhas_lidas.size())
        {
            // Setar o novo tamanho:
            tamanho = linhas_lidas.size();
            // Desalocar o texto anterior:
            delete[] texto;
            // Tentar alocar espaço para o novo texto:
            texto = new (nothrow) string[get_tamanho()];
            // Checar se deu certo:
            if(get_texto())
            {
                // Copiar o texto da lista temporária:
                for(list<string>::iterator p=linhas_lidas.begin() ; p!=linhas_lidas.end() ; p++)
                    texto[distance(linhas_lidas.begin(),p)] = *p;
                return(true);
            }
            // Caso ocorra algum erro...
            this->inicializador();
        }
    }
    return(false);
}

bool FileHandler::escrever(const char *arquivo_nome, string* txt, size_t tam)
{
    // Checar se os valores de "txt" e "tam" são válidos:
    if((txt == NULL) || (tam == 0)) return(false);
    // Abrir o arquivo para leitura:
    ofstream arquivo(arquivo_nome);
    if(arquivo.is_open())
    {
        for(size_t i=0 ; i<tam ; i++) arquivo<<txt[i]<<endl;
        arquivo.close();
        return(true);
    }
    return(false);
}
